package com.ydd.common.util;

import java.io.IOException;
import java.io.StringReader;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.htmlparser.Node;
import org.htmlparser.lexer.Lexer;
import org.htmlparser.nodes.TextNode;
import org.htmlparser.util.ParserException;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;

import java.lang.reflect.Method;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Map;  
import java.util.Random;  
  
import org.apache.commons.lang.StringUtils;  

/**
 * 字符串的帮助类，提供静态方法，不可以实例化。
 */
public class StrUtils {
	/**
	 * 禁止实例化
	 */
	private StrUtils() {
	}
	
	/** 
     * 空字符串 
     */  
    private static final String EMPTY_STR = "";  
    /** 
     * 分隔符 
     */  
    private static final String SEP = ",";  
    
    
    /** 
     * 将为NULL的String设置为空串。 
     *  
     * @param str 
     *            字符串 
     * @return String 
     */   
    public static String trimNull(String str) {  
        return str == null ? EMPTY_STR : str;  
    }  
      
    /** 
     * 将Object(MAP)中所有字符串类型字段为NULL的设置为空串。 
     *  
     * @param o 
     *            Object（Map） 
     */  
    public static void removeNullString(Object o) {  
        Class oclass = o.getClass();  
        Method[] methods = oclass.getMethods();  
        Map<String, Method> map = new HashMap<String, Method>();  
  
        for (int i = 0; i < methods.length; i++) {  
            Method method = methods[i];  
            String methodName = method.getName();  
            if (methodName.substring(0, 3).compareToIgnoreCase("set") == 0) {  
                Class p[] = method.getParameterTypes();  
                if (p.length == 1 && p[0].equals(String.class)) {  
                    map.put(methodName.substring(3), method);  
                }  
            }  
        }  
        for (int i = 0; i < methods.length; i++) {  
            Method method = methods[i];  
            String methodName = method.getName();  
            if (methodName.substring(0, 3).compareToIgnoreCase("get") == 0) {  
                Class p[] = method.getParameterTypes();  
                if (p.length == 0) {  
                    try {  
                        if (method.invoke(o) == null) {  
                            Method setMethod = map.get(methodName.substring(3));  
                            if (setMethod != null) {  
                                setMethod.invoke(o, "");  
                            }  
                        }  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
    }  
  
    /** 
     * 判断字符串是否为NULL和空串。 
     *  
     * @param str 
     *            字符串 
     * @return boolean 
     */  
    public static boolean isEmpty(String str) {  
        return !notEmpty(str);  
    }  
      
    /** 
     * 判断字符串是否不为NULL和空串。 
     *  
     * @param str 
     *            字符串 
     * @return boolean 
     */  
    public static boolean notEmpty(String str) {  
        return str != null && !str.trim().isEmpty();  
    }  
  
    /** 
     * 把一个list里面的所有str元素用提供的分隔符参数分开。 
     * <p> 
     * list为空，则返回一个空串。 
     *  
     * @param list 
     *            是Map的集合 
     * @param sep 
     *            length必须等于1 
     * @param key 
     *            是HMap中的id的key 
     * @return String 
     */  
    public static String listToString(List list, String sep, String key) {  
        StringBuffer sb = new StringBuffer();  
        Object obj;  
        Class clz;  
  
        if(sep == null || sep.length()!= 1) {  
            sep = SEP;  
        }  
        if(key == null || key.trim().length() <= 0) {  
            clz = String.class;  
        } else {  
            clz = Map.class;  
        }  
        for (Iterator it = list.iterator(); it.hasNext();) {  
            if(clz.equals(String.class)){  
                obj =  it.next();  
            }else{  
                obj = ((Map) it.next()).get(key);  
            }  
            sb.append(NVL(obj)).append(sep);  
        }  
  
        if (sb.length() > 0) {  
            sb = sb.deleteCharAt(sb.length() - 1);  
        }  
  
        return sb.toString();  
  
    }  
      
    /** 
     * 把一个list里面的所有str元素用提供的分隔符参数分开。 
     * <p> 
     * list为空，则返回一个空串。 
     *  
     * @param list 
     *            list 
     * @param sep 
     *            length必须等于1。 
     * @return String 
     */  
    public static String listToString(List list, String sep) {  
        return listToString(list,sep,null);  
  
    }  
  
    /** 
     * 把一个list里面的所有str元素用SEP分隔符分开。 
     * <p> 
     * list为空，则返回一个空串。 
     *  
     * @param list 
     *            list 
     * @return String 
     */  
    public static String listToString(List list) {  
        return listToString(list,SEP,null);  
    }  
      
    /** 
     * 在str中去除list中的所有id. 
     * <p> 
     *  
     * @param str 
     *            是用逗号分隔的ids。比如：1,2,3,4 
     * @param list 
     *            是str的集合。 
     * @return String 
     */  
    public static String stringExcepList(String str, List list) {  
        str = SEP + str + SEP;  
        String s;  
  
        for (Iterator it = list.iterator(); it.hasNext();) {  
            s = (String) it.next();  
            s = SEP + s + SEP;  
            str = str.replace(s, SEP);  
        }  
  
        if (str.length() > 2) {  
            str = str.substring(1, str.length() - 1);  
        } else {  
            str = "";  
        }  
  
        return str;  
    }  
  
    /** 
     * 在str中去除list中的所有id. 
     * <p> 
     *  
     * @param str 
     *            是用逗号分隔的ids。比如：1,2,3,4 
     * @param list 
     *            是Map的集合。 
     * @param key 
     *            是HMap中的id的key 
     * @return String 
     */  
    public static String stringExcepList(String str, List list, String key) {  
        str = SEP + str + SEP;  
        Map hs;  
        String s;  
  
        for (Iterator it = list.iterator(); it.hasNext();) {  
            hs = (Map) it.next();  
            s = (String) hs.get(key);  
            s = SEP + s + SEP;  
            str = str.replace(s, SEP);  
        }  
  
        if (str.length() > 2) {  
            str = str.substring(1, str.length() - 1);  
        } else {  
            str = "";  
        }  
  
        return str;  
    }  
      
    /** 
     * 將用逗號分割的ids中每個id用引號括起來。 
     *  
     * @param ids 
     *            ids 
     * @return String 
     */  
    public static String makeOracleNumberIdsToString(String ids) {  
        String ret = null;  
          
        if (ids == null || ids.length() <= 0) {  
            return ret;  
        }  
          
        ids = SEP + ids + SEP;  
        ids = ids.replaceAll(",", "','");  
        ret = ids.substring(2, ids.length() - 2);  
  
        return ret;  
    }  
      
    public static String list2Ids(List<String> ids){  
        String idstr = StringUtils.join(ids, SEP);  
        return makeOracleNumberIdsToString(idstr);  
    }  
      
    public static String array2Ids(String[] ids){  
        String idstr = StringUtils.join(ids, SEP);  
        return makeOracleNumberIdsToString(idstr);  
    }  
      
    /** 
     * 在已知ids后面增加id 
     *  
     * @param ids 
     *            ids 
     * @param id 
     *            id 
     * @return String 
     */  
    public static String appendToIds(String ids, String id) {  
        if (ids == null || ids.length() <= 0) {  
            ids = id;  
        } else {  
            ids = ids + SEP + id;  
        }  
  
        return ids;  
    }  
  
    /** 
     * fit dont asistant this character"〜" +301C so change 〜 +301c to ～ +ff5e 
     *  
     * @param str 
     *            str 
     * @return String 
     */  
    public static String treatSpecialChar(String str) {  
        if (str.indexOf(0x301C) >= 0) {  
            str = str.replace((char) 0x301C, (char) 0xff5e);  
        }  
        return str;  
    }  
  
    /** 
     * "A：xxx" ->"xxx" 
     *  
     * @param area 
     *            area 
     * @return String 
     */  
    public static String formatAreaStr(String area) {  
        if (area == null || area.equals("")) {  
            return area;  
        }  
        if (area.indexOf("：") < 0) {  
            return area;  
        }  
        area = area.substring(area.indexOf("：") + 1);  
        return area;  
    }  
  
    /** 
     * NVL 
     *  
     * @param Object 
     *            str 
     * @return String 
     */  
    public static String NVL(Object str) {  
        if (str == null) {  
            return "";  
        }  
        return NVL(str.toString());  
    }  
  
    /** 
     * NVL 
     *  
     * @param str 
     *            str 
     * @return String 
     */  
    public static String NVL(String str) {  
        if (str == null) {  
            return "";  
        }  
        if (str.equals("null")) {  
            return "";  
        }  
        if (str.equals("null|null")) {  
            return "";  
        }  
        return str;  
    }  
      
    public static boolean isTrue(String str) {  
        try {  
            return Boolean.parseBoolean(str);  
        } catch (Exception e) {  
            return false;  
        }  
    }  
      
    public static Long toLong(String str) {  
        if (isEmpty(str)) return null;  
        try {  
            return Long.parseLong(str);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
      
    public static Long toLong(String str, Long defaultValue) {  
        Long value = toLong(str);  
        return value == null ? defaultValue : value;  
    }  
      
    public static String fetchRandomString() {  
          
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssms");  
        return sdf.format(new Date()) + new Random().nextInt(1000);  
    }  

	/**
	 * 处理url
	 * 
	 * url为null返回null，url为空串或以http://或https://开头，则加上http://，其他情况返回原参数。
	 * 
	 * @param url
	 * @return
	 */
	public static String handelUrl(String url) {
		if (url == null) {
			return null;
		}
		url = url.trim();
		if (url.equals("") || url.startsWith("http://")
				|| url.startsWith("https://")) {
			return url;
		} else {
			return "http://" + url.trim();
		}
	}

	/**
	 * 分割并且去除空格
	 * 
	 * @param str
	 *            待分割字符串
	 * @param sep
	 *            分割符
	 * @param sep2
	 *            第二个分隔符
	 * @return 如果str为空，则返回null。
	 */
	public static String[] splitAndTrim(String str, String sep, String sep2) {
		if (StringUtils.isBlank(str)) {
			return null;
		}
		if (!StringUtils.isBlank(sep2)) {
			str = StringUtils.replace(str, sep2, sep);
		}
		String[] arr = StringUtils.split(str, sep);
		// trim
		for (int i = 0, len = arr.length; i < len; i++) {
			arr[i] = arr[i].trim();
		}
		return arr;
	}

	/**
	 * 文本转html
	 * 
	 * @param txt
	 * @return
	 */
	public static String txt2htm(String txt) {
		if (StringUtils.isBlank(txt)) {
			return txt;
		}
		StringBuilder sb = new StringBuilder((int) (txt.length() * 1.2));
		char c;
		boolean doub = false;
		for (int i = 0; i < txt.length(); i++) {
			c = txt.charAt(i);
			if (c == ' ') {
				if (doub) {
					sb.append(' ');
					doub = false;
				} else {
					sb.append("&nbsp;");
					doub = true;
				}
			} else {
				doub = false;
				switch (c) {
				case '&':
					sb.append("&amp;");
					break;
				case '<':
					sb.append("&lt;");
					break;
				case '>':
					sb.append("&gt;");
					break;
				case '"':
					sb.append("&quot;");
					break;
				case '\n':
					sb.append("<br/>");
					break;
				default:
					sb.append(c);
					break;
				}
			}
		}
		return sb.toString();
	}

	/**
	 * 剪切文本。如果进行了剪切，则在文本后加上"..."
	 * 
	 * @param s
	 *            剪切对象。
	 * @param len
	 *            编码小于256的作为一个字符，大于256的作为两个字符。
	 * @return
	 */
	public static String textCut(String s, int len, String append) {
		if (s == null) {
			return null;
		}
		int slen = s.length();
		if (slen <= len) {
			return s;
		}
		// 最大计数（如果全是英文）
		int maxCount = len * 2;
		int count = 0;
		int i = 0;
		for (; count < maxCount && i < slen; i++) {
			if (s.codePointAt(i) < 256) {
				count++;
			} else {
				count += 2;
			}
		}
		if (i < slen) {
			if (count > maxCount) {
				i--;
			}
			if (!StringUtils.isBlank(append)) {
				if (s.codePointAt(i - 1) < 256) {
					i -= 2;
				} else {
					i--;
				}
				return s.substring(0, i) + append;
			} else {
				return s.substring(0, i);
			}
		} else {
			return s;
		}
	}

	public static String htmlCut(String s, int len, String append) {
		String text = html2Text(s, len * 2);
		return textCut(text, len, append);
	}

	public static String html2Text(String html, int len) {
		try {
			Lexer lexer = new Lexer(html);
			Node node;
			StringBuilder sb = new StringBuilder(html.length());
			while ((node = lexer.nextNode()) != null) {
				if (node instanceof TextNode) {
					sb.append(node.toHtml());
				}
				if (sb.length() > len) {
					break;
				}
			}
			return sb.toString();
		} catch (ParserException e) {
			throw new RuntimeException(e);
		}
	}
	
	/**
	 * 
	 * @param keyword 源词汇
	 * @param smart 是否智能分词
	 * @return 分词词组(,拼接)
	 */
	public static String getKeywords(String keyword, boolean smart) {
		StringReader reader = new StringReader(keyword);
		IKSegmenter iks = new IKSegmenter(reader, smart);
		StringBuilder buffer = new StringBuilder();
		try {
			Lexeme lexeme;
			while ((lexeme = iks.next()) != null) {
				buffer.append(lexeme.getLexemeText()).append(',');
			}
		} catch (IOException e) {
		}
		//去除最后一个,
		if (buffer.length() > 0) {
			buffer.setLength(buffer.length() - 1);
		}
		return buffer.toString();
	}

	/**
	 * 检查字符串中是否包含被搜索的字符串。被搜索的字符串可以使用通配符'*'。
	 * 
	 * @param str
	 * @param search
	 * @return
	 */
	public static boolean contains(String str, String search) {
		if (StringUtils.isBlank(str) || StringUtils.isBlank(search)) {
			return false;
		}
		String reg = StringUtils.replace(search, "*", ".*");
		Pattern p = Pattern.compile(reg);
		return p.matcher(str).matches();
	}

	public static boolean containsKeyString(String str) {
		if (StringUtils.isBlank(str)) {
			return false;
		}
		if (str.contains("'") || str.contains("\"") || str.contains("\r")
				|| str.contains("\n") || str.contains("\t")
				|| str.contains("\b") || str.contains("\f")) {
			return true;
		}
		return false;
	}

	// 将""和'转义
	public static String replaceKeyString(String str) {
		if (containsKeyString(str)) {
			return str.replace("'", "\\'").replace("\"", "\\\"").replace("\r",
					"\\r").replace("\n", "\\n").replace("\t", "\\t").replace(
					"\b", "\\b").replace("\f", "\\f");
		} else {
			return str;
		}
	}
	
	public static String getSuffix(String str) {
		int splitIndex = str.lastIndexOf(".");
		return str.substring(splitIndex + 1);
	}

	public static void main(String args[]) {
		System.out.println(replaceKeyString("&nbsp;\r" + "</p>"));
	}

}
